﻿using System;
using NUnit.Framework;
using FluentAssertions;

namespace Learning
{
  [TestFixture]
  public class BubbleSort
  {
    public void Sort(int[] array)
    {
     
      
      for (int i = 1; i < array.Length; i++)
      {
        int flag = 0;
        for (int j = 0; j < array.Length - i; j++)
        {
          
          _compareCounter++;
          if (array[j] > array[j + 1])
          {
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
            _swapCounter++;
            flag = 1;
          }
          
        }
          if (flag==0)
          {
            break;
          }
      }




      /*
       * Этому методу в качестве аргумента передан массив для сортировки.
       * Здесь должен быть текст программы.
       * 
       * Когда все тесты пройдут, читай коммент в методе TestSetUp
       */
    }

    private int _compareCounter;
    private int _swapCounter;
    private bool _checkCounters;

    [SetUp]
    public void TestSetUp()
    {
      /*
       * Расставь в своей сортировке счетчики:
       * _compareCounter - счетчик сравнений
       * _swapCounter - счетчик перестановок
       * и измени значение _checkCounters на "true".
       * 
       * Смысл задания в том, что сортировка пузырьком
       * не должна требовать больше определенного количества
       * сравнений и перестановок.
       * 
       */
      _compareCounter = 0;
      _swapCounter = 0;
      _checkCounters = true;
    }

    [Test]
    public void SortEmpty()
    {
      var arr = new int[0];
      Sort(arr);
      arr.Should().BeEmpty();

      if (!_checkCounters) return;
      _compareCounter.Should().Be(0);
      _swapCounter.Should().Be(0);
    }
    [Test]
    public void SortOneElement()
    {
      var arr = new[] { 3 };
      Sort(arr);
      arr.Should().Equal(3);

      if (!_checkCounters) return;
      _compareCounter.Should().Be(0);
      _swapCounter.Should().Be(0);
    }
    [Test]
    public void SortWhatAlreadySorted()
    {
      var arr = new[] { 1, 2, 3, 4, 5 };
      Sort(arr);
      arr.Should().Equal(1, 2, 3, 4, 5);

      if (!_checkCounters) return;
      _compareCounter.Should().BeLessOrEqualTo(4);
      _swapCounter.Should().Be(0);
    }
    [Test]
    public void SortWithOneExchange()
    {
      var arr = new[] { 1, 3, 2, 4, 5 };
      Sort(arr);
      arr.Should().Equal(1, 2, 3, 4, 5);

      if (!_checkCounters) return;
      _compareCounter.Should().BeLessOrEqualTo(7);
      _swapCounter.Should().Be(1);
    }
    [Test]
    public void SortWithBubblingElement()
    {
      var arr = new[] { 1, 2, 3, 4, 0 };
      Sort(arr);
      arr.Should().Equal(0, 1, 2, 3, 4);

      if (!_checkCounters) return;
      _compareCounter.Should().BeLessOrEqualTo(10);
      _swapCounter.Should().Be(4);
    }
  }
}
